Real-time system overheads : a literature overview

In most contemporary systems there are several jobs concurrently competing for shared resources, such as a processor, memory, network, sensors or other devices. Sharing a resource between several jobs requires synchronizing the jobs, specifying when which job will have access to the resource. A common synchronization method is scheduling. Executing a schedule requires switching resource assignments between the jobs, which is usually referred to as context switching. The overheads associated with scheduling and context switching are part of the system overheads. Initially, in the spirit of keeping things simple, real-time systems analysis abstracted from many details, including the overheads incurred by the operating system. This has led to inherently opti-mistic results, i.e. accepting collections of jobs, which if executed on a real system will fail to meet all the constraints. In this paper we consider a less idealized platform by taking some practical aspects into account. We present an overview of literature dealing with real-time system overheads, in particular the scheduling and context switch overheads. We focus on sharing a single timely resource, such as a processor, in the context of Fixed Priority Preemptive Scheduling. We treat in detail the overhead

Multi-resource management in embedded real-time systems

This thesis addresses the problem of online multi-resource management in embedded real-time systems. It focuses on three research questions. The first question concentrates on how to design an efficient hierarchical scheduling framework for supporting independent development and analysis of component based systems, to provide temporal isolation between components. The second question investigates how to change the mapping of resources to tasks and components during run-time efficiently and predictably, and how to analyze the latency of such a system mode change in systems comprised of several scalable components. The third question deals with the scheduling and analysis of a set of parallel-tasks with real-time constraints which require simultaneous access to several different resources. For providing temporal isolation we chose a reservation-based approach. We first focused on processor reservations, where timed events play an important role. Common examples are task deadlines, periodic release of tasks, budget replenishment and budget depletion. Efficient timer management is therefore essential. We investigated the overheads in traditional timer management techniques and presented a mechanism called Relative Timed Event Queues (RELTEQ), which provides an expressive set of primitives at a low processor and memory overhead. We then leveraged RELTEQ to create an efficient, modular and extensible design for enhancing a real-time operating system with periodic tasks, polling, idling periodic and deferrable servers, and a two-level fixed-priority Hierarchical Scheduling Framework (HSF). The HSF design provides temporal isolation and supports independent development of components by separating the global and local scheduling, and allowing each server to define a dedicated scheduler. Furthermore, the design addresses the system overheads inherent to an HSF and prevents undesirable interference between components. It limits the interference of inactive servers on the system level by means of wakeup events and a combination of inactive server queues with a stopwatch queue. Our implementation is modular and requires only a few modifications of the underlying operating system. We then investigated scalable components operating in a memory-constrained system. We first showed how to reduce the memory requirements in a streaming multimedia application, based on a particular priority assignment of the different components along the processing chain. Then we investigated adapting the resource provisions to tasks during runtime, referred to as mode changes. We presented a novel mode change protocol called Swift Mode Changes, which relies on Fixed Priority with Deferred preemption Scheduling to reduce the mode change latency bound compared to existing protocols based on Fixed Priority Preemptive Scheduling. We then presented a new partitioned parallel-task scheduling algorithm called Parallel-SRP (PSRP), which generalizes MSRP for multiprocessors, and the corresponding schedulability analysis for the problem of multi-resource scheduling of parallel tasks with real-time constraints. We showed that the algorithm is deadlock-free, derived a maximum bound on blocking, and used this bound as a basis for a schedulability test. We then demonstrated how PSRP can exploit the inherent parallelism of a platform comprised of multiple heterogeneous resources. Finally, we presented Grasp, which is a visualization toolset aiming to provide insight into the behavior of complex real-time systems. Its flexible plugin infrastructure allows for easy extension with custom visualization and analysis techniques for automatic trace verification. Its capabilities include the visualization of hierarchical multiprocessor systems, including partitioned and global multiprocessor scheduling with migrating tasks and jobs, communication between jobs via shared memory and message passing, and hierarchical scheduling in combination with multiprocessor scheduling. For tracing distributed systems with asynchronous local clocks Grasp also supports the synchronization of traces from different processors during the visualization and analysis

Grasp : visualizing the behavior of hierarchical multiprocessor real-time systems

Trace visualization is a viable approach for gaining insight into the behavior of complex distributed real-time systems. Grasp is a versatile trace visualization toolset. This paper presents its unique visualization capabilities for hierarchical multiprocessor systems, including partitioned and global multiprocessor scheduling with migrating tasks and jobs, communication between jobs via shared memory and message passing, and hierarchical scheduling in combination with multiprocessor scheduling. Its flexible plugin infrastructure allows for easy extension with custom visualization and analysis techniques for automatic trace verification. Grasp is freely available on the web

Extending an open-source real-time operating system with hierarchical scheduling

Hierarchical scheduling frameworks (HSFs) have been devised to support the integration of independently developed and analyzed subsystems. This paper presents an efficient, modular and extendible design for enhancing a real-time operating system with periodic tasks, two-level fixed-priority HSF based on the idling periodic and deferrable servers, and virtual timers. It relies on Relative Timed Event Queues (RELTEQ), a timed event management component targeted at embedded operating systems, which supports long event interarrival time, long lifetime of the event queue, no drift and low overhead. It minimizes the overhead in terms of processor and memory usage, limits the interference of inactive servers on system level, and minimizes the necessary modifications of the underlying operating system. The proposed design was implemented and evaluated within the µC/OS-II real-time operating system used by our industrial and academic partners

Extending RTA/Linux with fixed-priority scheduling with deferred preemption

Fixed-Priority Scheduling with Deferred Preemption (FPDS) is a middle ground between Fixed-Priority Pre-emptive Scheduling and Fixed-Priority Non-preemptive Scheduling, and offers advantages with respect to context switch overhead and resource access control. In this paper we present our work on extending the real-time operating system RTAI/Linux with support for FPDS. We give an overview of possible alternatives, describe our design choices and implementation, and verify through a series of measurements that indicate that a FPDS implementation in a real-world RTOS is feasible with minimal overhead

Constant-bandwith supply for priority processing

Today's consumer electronic devices feature multiple applications which have to share scarcely available resources. We consider a priority-processing-based video application, which comprises multiple scalable video algorithms (SVAs) that are executed on a shared, virtual platform. This application is given a guaranteed processor share by means of a constant-bandwidth server (CBS), which in addition efficiently reclaims all spare processor time. A decision scheduler distributes the assigned processor share among the SVAs, with the aim to maximize their overall output quality. To correctly distribute this processor share we introduce the concept of a virtual timer. This timer only advances when its associated virtual platform is executing

Grasp: Tracing, visualizing and measuring the behavior of real-time systems

Understanding and validating the timing behavior of real-time systems is not trivial. Many real-time operating systems and their development environments do not provide tracing support, and provide only limited visualization, measurements and analysis tools. This paper presents Grasp, a tool for tracing, visualizing and measuring the behavior of real-time systems. Grasp provides a simple plugin infrastructure for extending it with custom visualization and measurement methods. The functionality of Grasp is demonstrated based on experiences during the development of various real-time extensions for the commercially available µC/OS-II real-time operating system. All the tools presented in this paper are open source and freely available on the web

Virtual timers in hierarchical real-time systems

Hierarchical scheduling frameworks (HSFs) provide means for composing complex real-time systems from welldefined subsystems. This paper describes an approach to provide hierarchically scheduled real-time applications with virtual event timers, motivated by the need for integrating priority processing applications in an HSF. Specifically, the paper proposes a technique to minimize the overhead of event handling in HSFs and outlines a simple implementation